¿Cuál es la diferencia entre 'git pull' y 'git fetch'?

1
2
Siguiente
En los términos más simples, git pull hace un git fetch seguido de un git merge.
Puede hacer una búsqueda de git en cualquier momento para actualizar sus ramas de seguimiento remoto en refs / remotes /  /.
Esta operación nunca cambia ninguna de sus sucursales locales bajo referencias / encabezados, y es segura sin cambiar su copia de trabajo. Incluso he oído hablar de personas que ejecutan git fetch periódicamente en un trabajo cron en segundo plano (aunque no recomendaría hacer esto).
Un git pull es lo que haría para actualizar una sucursal local con su versión remota, al tiempo que actualiza sus otras sucursales de seguimiento remoto.
De la documentación de Git para git pull:
En su modo predeterminado, git pull es la abreviatura de git fetch seguido de git merge FETCH_HEAD.
|
Cuando usas pull, Git intenta hacer tu trabajo automáticamente por ti. Es sensible al contexto, por lo que Git fusionará todas las confirmaciones extraídas en la rama en la que está trabajando actualmente. Pull fusiona automáticamente las confirmaciones sin permitirle revisarlas primero. Si no administra de cerca sus sucursales, puede encontrarse con conflictos frecuentes.
Cuando recupera, Git recopila las confirmaciones de la rama de destino que no existen en su rama actual y las almacena en su repositorio local. Sin embargo, no los fusiona con su rama actual. Esto es particularmente útil si necesita mantener su repositorio actualizado, pero está trabajando en algo que podría fallar si actualiza sus archivos.
Para integrar las confirmaciones en su rama maestra, usa merge.
|
Es importante contrastar la filosofía de diseño de git con la filosofía de una herramienta de control de fuente más tradicional como SVN.
Subversion fue diseñado y construido con un modelo cliente / servidor. Hay un único repositorio que es el servidor, y varios clientes pueden recuperar el código del servidor, trabajar en él y luego enviarlo de nuevo al servidor. Se asume que el cliente siempre puede contactar al servidor cuando necesita realizar una operación.
Git fue diseñado para admitir un modelo más distribuido sin necesidad de un repositorio central (aunque ciertamente puede usar uno si lo desea). Además, git fue diseñado para que el cliente y el "servidor" no necesiten estar en línea al mismo tiempo. Git fue diseñado para que las personas en un enlace no confiable pudieran intercambiar código por correo electrónico, incluso. Es posible trabajar completamente desconectado y grabar un CD para intercambiar código a través de git.
Para admitir este modelo, git mantiene un repositorio local con su código y también un repositorio local adicional que refleja el estado del repositorio remoto. Al mantener una copia del repositorio remoto localmente, git puede descubrir los cambios necesarios incluso cuando no se puede acceder al repositorio remoto. Más adelante, cuando necesite enviar los cambios a otra persona, git puede transferirlos como un conjunto de cambios desde un punto en el tiempo conocido por el repositorio remoto.
git fetch es el comando que dice "actualizar mi copia local del repositorio remoto".
git pull dice "llevar los cambios en el repositorio remoto donde guardo mi propio código".
Normalmente, git pull hace esto haciendo un git fetch para actualizar la copia local del repositorio remoto y luego fusionar los cambios en su propio repositorio de código y posiblemente en su copia de trabajo.
La conclusión es tener en cuenta que a menudo hay al menos tres copias de un proyecto en su estación de trabajo. Una copia es su propio repositorio con su propio historial de confirmaciones. La segunda copia es su copia de trabajo donde está editando y construyendo. La tercera copia es su copia local "en caché" de un repositorio remoto.
|
Aquí está la imagen de Oliver Steele de cómo encaja todo:
Si hay suficiente interés, supongo que podría actualizar la imagen para agregar git clone y git merge ...
|
Un caso de uso de git fetch es que lo siguiente le indicará cualquier cambio en la rama remota desde su última extracción ... para que pueda verificar antes de realizar una extracción real, lo que podría cambiar los archivos en su rama actual y copia de trabajo.
git fetch
git diff ... origen
Consulte: https://git-scm.com/docs/git-diff con respecto a la sintaxis de doble y triple punto en el comando diff
|
Me costó un poco entender cuál era la diferencia, pero esta es una explicación simple. master en su localhost es una rama.
Cuando clonas un repositorio, recuperas todo el repositorio en tu host local. Esto significa que en ese momento tiene un puntero de origen / maestro a HEAD y un maestro apuntando al mismo HEAD.
cuando comienzas a trabajar y haces confirmaciones, avanzas el puntero maestro a HEAD + tus confirmaciones. Pero el puntero de origen / maestro sigue apuntando a lo que era cuando clonó.
Entonces la diferencia será:
Si realiza una búsqueda de git, solo obtendrá todos los cambios en el repositorio remoto (GitHub) y moverá el puntero de origen / maestro a HEAD. Mientras tanto, su maestro de sucursal local seguirá apuntando hacia donde tiene.
Si hace un git pull, básicamente buscará (como se explicó anteriormente) y fusionará cualquier cambio nuevo en sumaster branch y mueva el puntero a HEAD.
|
A veces, una representación visual ayuda.
|
Brevemente
git fetch es similar a pull pero no se fusiona. es decir, obtiene actualizaciones remotas (referencias y objetos) pero su local permanece igual (es decir, el origen / maestro se actualiza pero el maestro permanece igual).
git pull se despliega desde un control remoto y se fusiona instantáneamente.
Más
git clone clona un repositorio.
git rebase guarda cosas de su rama actual que no están en la rama ascendente a un área temporal. Su rama ahora es la misma que antes de comenzar con los cambios. Entonces, git pull -rebase desplegará los cambios remotos, rebobinará su rama local, reproducirá sus cambios en la parte superior de su rama actual uno por uno hasta que esté actualizado.
Además, git branch -a te mostrará exactamente lo que está sucediendo con todas tus ramas, locales y remotas.
Esta publicación de blog fue útil:
La diferencia entre git pull, git fetch y git clone (y git rebase) - Mike Pearce
y cubre git pull, git fetch, git clone y git rebase.
====
ACTUALIZAR
Pensé en actualizar esto para mostrar cómo lo usarías en la práctica.
Actualice su repositorio local desde el control remoto (pero no fusione):
git fetch
Después de descargar las actualizaciones, veamos las diferencias:
git diff master origen / maestro
Si está satisfecho con esas actualizaciones, combine:
git pull
Notas:
En el paso 2: para obtener más información sobre las diferencias entre locales y remotos, consulte: ¿Cómo comparar una rama de git local con su rama remota?
En el paso 3: probablemente sea más preciso (por ejemplo, en un repositorio que cambia rápidamente) hacer un origen de git rebase aquí. Vea el comentario de @Justin Ohms en otra respuesta.
Véase también: http://longair.net/blog/2009/04/16/git-fetch-and-merge/
|
git-pull - Obtener y fusionar con otro repositorio o una rama local
SINOPSIS
git pull…
DESCRIPCIÓN
Ejecuta git-fetch con los parámetros dados y llama a git-merge para fusionar el
cabeza (s) recuperada (s) en la rama actual. Con --rebase, llama a git-rebase
en lugar de git-merge.
Tenga en cuenta que puede usar. (directorio actual) como  para extraer
desde el repositorio local: esto es útil cuando se combinan ramas locales
en la rama actual.
También tenga en cuenta que las opciones destinadas a git-pull en sí y git-merge subyacente
debe darse antes de las opciones destinadas a git-fetch.
Tirarías si quieres que las historias se fusionen, buscarías si solo 'quieres el codez' ya que alguna persona ha estado etiquetando algunos artículos por aquí.
|
Puede buscar desde un repositorio remoto, ver las diferencias y luego extraer o fusionar.
Este es un ejemplo de un repositorio remoto llamado origen y una rama llamada maestra que rastrea el origen / maestro de la rama remota:
maestro de git checkout
git fetch
git diff origin / master
maestro de origen de git rebase
|
La respuesta corta y fácil es que git pull es simplemente git fetch seguido de git merge.
Es muy importante tener en cuenta que git pull se fusionará automáticamente, te guste o no. Por supuesto, esto podría resultar en conflictos de fusión. Digamos que su control remoto es el origen y su rama es el maestro. Si git diff origin / master antes de extraer, debería tener alguna idea de los posibles conflictos de fusión y podría preparar su sucursal local en consecuencia.
Además de tirar y empujar, algunos flujos de trabajo involucran git rebase, como este, que parafraseo del artículo vinculado:
maestro de origen de git pull
git checkout foo-branch
maestro de git rebase
git push origin foo-branch
Si se encuentra en tal situación, puede tener la tentación de git pull --rebase. A menos que realmente sepa lo que está haciendo, no lo desaconsejaría. Esta advertencia es de la página de manual de git-pull, versión 2.3.5:
Este es un modo de funcionamiento potencialmente peligroso. Reescribe
historia, que no augura nada bueno cuando publicaste esa historia
ya. No use esta opción a menos que haya leído git-rebase (1)
cuidadosamente.
|
De acuerdo, aquí hay información sobre git pull y git fetch, para que pueda comprender las diferencias reales ... en pocas palabras simples, fetch obtiene los datos más recientes, pero no el código cambia y no va a interferir con su código de sucursal local actual , pero obtenga los cambios de código y combínelos con su sucursal local, siga leyendo para obtener más detalles sobre cada uno:
git fetch
Descargará todas las referencias y objetos y cualquier nueva rama a su Repositorio local ...
Obtener ramas o etiquetas (colectivamente, "referencias") de uno o más
otros repositorios, junto con los objetos necesarios para completar su
historias. Se actualizan las sucursales de seguimiento remoto (consulte la descripción
a continuación para conocer las formas de controlar este comportamiento).
De forma predeterminada, cualquier etiqueta que apunte a los historiales que se están recuperando es
también traído; el efecto es buscar etiquetas que apuntan a ramas que
que le interesa. Este comportamiento predeterminado se puede cambiar utilizando
las opciones --tags o --no-tags o configurando
remote..tagOpt. Al usar una refspec que recupera etiquetas de forma explícita,
puede buscar etiquetas que no apunten a las ramas que le interesan
en también.
git fetch puede recuperar deya sea un único repositorio con nombre o URL, o
de varios repositorios a la vez si se da y hay un
mandos a distancia. entrada en el archivo de configuración. (Ver git-config1).
Cuando no se especifica ningún control remoto, por defecto el control remoto de origen será
utilizado, a menos que haya una rama ascendente configurada para la corriente
rama.
Los nombres de las referencias que se obtienen, junto con los nombres de los objetos.
apuntan, se escriben en .git / FETCH_HEAD. Esta información puede ser
utilizado por scripts u otros comandos de git, como git-pull.
git pull
Aplicará los cambios de remoto a la rama actual en local ...
Incorpora cambios de un repositorio remoto en la rama actual.
En su modo predeterminado, git pull es la abreviatura de git fetch seguido de
git fusionar FETCH_HEAD.
Más precisamente, git pull ejecuta git fetch con los parámetros dados y
llama a git merge para fusionar los ramales recuperados en el actual
rama. Con --rebase, ejecuta git rebase en lugar de git merge.
debe ser el nombre de un repositorio remoto como se pasó a
git-fetch1. puede nombrar una referencia remota arbitraria (por ejemplo,
el nombre de una etiqueta) o incluso una colección de referencias con los correspondientes
ramas de seguimiento remoto (por ejemplo, refs / heads /: refs / remotes / origin /),
pero generalmente es el nombre de una rama en el repositorio remoto.
Los valores predeterminados para y se leen del
Configuración "remota" y "fusionar" para la rama actual según lo establecido por
git-branch: pista.
También creo la imagen a continuación para mostrarte cómo git fetch y git pull funcionan juntos ...
|
Esta representación gráfica interactiva es muy útil para comprender git: http://ndpsoftware.com/git-cheatsheet.html
git fetch simplemente "descarga" los cambios desde el control remoto a su repositorio local. git pull descarga los cambios y los fusiona en su rama actual. "En su modo predeterminado, git pull es la abreviatura de git fetch seguido de git merge FETCH_HEAD".
|
Prima:
Al hablar de pull & fetch en las respuestas anteriores, me gustaría compartir un truco interesante,
git pull --rebase
Este comando anterior es el comando más útil en mi vida de git que me ahorró mucho tiempo.
Antes de enviar sus nuevas confirmaciones al servidor, pruebe este comando y sincronizará automáticamente los últimos cambios del servidor (con una búsqueda + combinación) y colocará su confirmación en la parte superior del registro de git. No hay necesidad de preocuparse por la combinación / extracción manual.
Encuentre detalles en: http://gitolite.com/git-pull--rebase
|
Me gusta tener alguna representación visual de la situación para captar estas cosas. Quizás a otros desarrolladores también les gustaría verlo, así que aquí está mi adición. No estoy totalmente seguro de que todo sea correcto, así que comente si encuentra algún error.
SISTEMA LOCAL
. ================================================ ===
=================. ================= =================== =============
REPOSITORIO REMOTO. REPOSITORIO REMOTO REPOSITORIO LOCAL COPIA DE FUNCIONAMIENTO
(ORIGEN). (CACHED)
por ejemplo,      . espejo del
un repositorio de github. . repositorio remoto
Puede también ser       .
múltiples repositorios.
.
.
BUSCAR * ------------------> *
Su caché local del control remoto se actualiza con el origen (o múltiples
fuentes externas, esa es la naturaleza distribuida de git)
.
HALAR   *------------------------------------------------ --------> *
los cambios se combinan directamente en su copia local. cuando ocurren conflictos,
se le pide decisiones.
.
COMPROMISO. * <--------------- *
Cuando viene de, por ejemplo, subversión, podría pensar que una confirmación
actualizará el origen. En git, solo se realiza una confirmación en su repositorio local.
.
EMPUJE * <--------------------------------------- *
Sincroniza sus cambios nuevamente en el origen.
Algunas de las principales ventajas de tener un espejo recuperado del control remoto son:
Rendimiento (desplácese por todas las confirmaciones y mensajes sin tratar de exprimirlo a través de la red)
Comentarios sobre el estado de su repositorio local (por ejemplo, utilizo SourceTree de Atlassian, que me dará una bombilla que indica si me comprometo adelante o atrás en comparación con el origen. Esta información se puede actualizar con un GIT FETCH).
|
Yo también he luchado con esto. De hecho, llegué aquí con una búsqueda en Google de exactamente la misma pregunta. Al leer todas estas respuestas, finalmente pinté una imagen en mi cabeza y decidí intentar descifrar esto mirando el estado de los 2 repositorios y 1 caja de arena y las acciones realizadas a lo largo del tiempo mientras veía la versión de ellos. Así que esto es lo que se me ocurrió. Por favor, corrígeme si me equivoqué en alguna parte.
Los tres repositorios con fetch:
--------------------- ----------------------- ------ -----------------
- Repositorio remoto - - Repositorio remoto - - Repositorio remoto -
- - - se empuja - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------------------------------
- Repo local - - Repo local - - Repo local -
- tirar - - - - buscar -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Sandbox local - - Sandbox local - - Sandbox local -
- Pago - - Nuevo trabajo realizado - - -
- @ R01 - - @ R01 + - - @ R01 + -
--------------------- ----------------------- ------ -----------------
Los tres repos con un tirón
--------------------- ----------------------- ------ -----------------
- Repositorio remoto - - Repositorio remoto - - Repositorio remoto -
- - - se empuja - - -
- @ R01 - - @ R02 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Repo local - - Repo local - - Repo local -
- tirar - - - - tirar -
- @ R01 - - @ R01 - - @ R02 -
--------------------- ----------------------- ------ -----------------
--------------------- ----------------------- ------ -----------------
- Sandbox local - - Sandbox local - - Sandbox local -
- Pago - - Nuevo trabajo realizado - - Combinado con R02 -
- @ R01 - - @ R01 + - - @ R02 + -
--------------------- ----------------------- ------ -----------------
Esto me ayudó a entender por qué la búsqueda es muy importante.
|
La diferencia entre GIT Fetch y GIT Pull se puede explicar con el siguiente escenario:
(¡Teniendo en cuenta que las imágenes hablan más que las palabras !, he proporcionado una representación pictórica)
Tomemos un ejemplo de que está trabajando en un proyecto con los miembros de su equipo. Entonces, habrá una rama principal del proyecto y todos los contribuyentes deben bifurcarla a su propio repositorio local y luego trabajar en esta rama local para modificar / agregar módulos y luego regresar a la rama principal.
Entonces,
El estado inicial de las dos ramas cuando bifurcó el proyecto principal en su repositorio local será así: (A, B y C son módulos ya completados del proyecto)
Ahora, ha comenzado a trabajar en el nuevo módulo (suponga D) y cuando haya completado el módulo D, desea empujarlo a la rama principal, pero mientras tanto lo que sucede es que uno de sus compañeros de equipo ha desarrollado nuevos módulos E, F y modificado C.
Entonces, lo que ha sucedido ahora es que su repositorio local no está detrás del progreso original del proyecto y, por lo tanto, impulsar sus cambios a la rama principal puede generar conflictos y hacer que su Módulo D funcione mal.
Para evitar este tipo de problemas y trabajar en paralelo con el progreso original del proyecto, existen dos formas:
1. Git Fetch- Esto descargará todos los cambios que se han realizado en el proyecto de rama principal / origen que no están presentes en su rama local. Y esperará a que el comando Git Merge aplique los cambios que se han obtenido en su repositorio o rama.
Entonces ahora puede monitorear cuidadosamente los archivos antes de fusionarlos en su repositorio. Y también puede modificar D si es necesario debido a C.
2. Git Pull- Esto actualizará su rama local con el origen / rama principal, es decir, en realidad lo que hace es una combinación de Git Fetch y Git se fusionan uno tras otro.
Pero esto puede causar conflictos, por lo que se recomienda usar Git Pull con una copia limpia.
|
Simplemente decimos:
git pull == git fetch + git merge
Si ejecuta git pull, no necesita fusionar los datos en local. Si ejecuta git fetch, significa que debe ejecutar git merge para obtener el último código en su máquina local. De lo contrario, el código de la máquina local no se cambiaría sin la fusión.
Entonces, en Git Gui, cuando recuperas, debes fusionar los datos. Fetch no hará cambios en el código en su local. Puede comprobarlo cuando actualice el código obteniendo
una vez buscar y ver; el código no cambiará. Luego fusiona ... Verá el código cambiado.
|
git fetch extrae el código del servidor remoto a sus ramas de seguimiento en su repositorio local. Si su control remoto se llama origen (el predeterminado), entonces estas ramas estarán dentro de origen /, por ejemplo, origen / maestro, origen / mybranch-123, etc. .
git pull hace un git fetch pero luego también fusiona el código de la rama de seguimiento en su actualversión local de esa rama. Si aún no está listo para esos cambios, solo git fetch primero.
|
git fetch recuperará las ramas remotas para que pueda git diff o git fusionarlas con la rama actual. git pull ejecutará fetch en el brach remoto rastreado por la rama actual y luego fusionará el resultado. Puede usar git fetch para ver si hay actualizaciones para la rama remota sin necesidad de fusionarlas con su rama local.
|
Git Fetch
Descarga los cambios a su sucursal local desde el origen hasta la recuperación. Fetch solicita al repositorio remoto todas las confirmaciones que otros han realizado pero que usted no tiene en su repositorio local. Fetch descarga estas confirmaciones y las agrega al repositorio local.
Git Merge
Puede aplicar los cambios descargados a través de la recuperación mediante el comando fusionar. Merge tomará las confirmaciones recuperadas de fetch e intentará agregarlas a su rama local. La fusión mantendrá el historial de confirmación de sus cambios locales para que cuando comparta su rama con push, Git sepa cómo otros pueden fusionar sus cambios.
Git Pull
Obtener y fusionar se ejecutan juntos con la suficiente frecuencia como para crear un comando que combina los dos, extraer. Pull realiza una búsqueda y luego una fusión para agregar las confirmaciones descargadas en su rama local.
|
En términos simples, si estuviera a punto de subirse a un avión sin ninguna conexión a Internet ... antes de partir, podría simplemente hacer git fetch origin . Buscaría todos los cambios en su computadora, pero lo mantendría separado de su espacio de trabajo / desarrollo local.
En el avión, puede realizar cambios en su espacio de trabajo local y luego fusionarlo con lo que ha obtenido y resolver posibles conflictos de fusión, todo sin una conexión a Internet. Y a menos que alguien haya realizado nuevos cambios en el repositorio remoto, una vez que llegue al destino, haría git push origin  e iría a buscar su café.
De este increíble tutorial de Atlassian:
El comando git fetch descarga confirmaciones, archivos y referencias de una
repositorio remoto en su repositorio local.
Buscar es lo que haces cuando quieres ver lo que todos los demás tienen
estado trabajando. Es similar a la actualización SVN en que le permite ver
cómo ha progresado la historia central, pero no te obliga a
en realidad fusiona los cambios en tu repositorio. Aislados de Git
obtenido como contenido local existente, tiene absolutamente
ningún efecto en su trabajo de desarrollo local. El contenido obtenido debe ser verificado explícitamente usando el comando git checkout. Esto hace
buscar una forma segura de revisar las confirmaciones antes de integrarlas con
su repositorio local.
Al descargar contenido de un repositorio remoto, los comandos git pull y git fetch están disponibles para realizar la tarea. Puedes considerar
git busca la versión 'segura' de los dos comandos. Se descargará
el contenido remoto, pero no actualice el estado de funcionamiento de su repositorio local,
dejando intacto su trabajo actual. git pull es el más agresivo
alternativa, descargará el contenido remoto para el local activo
bifurcar e inmediatamente ejecutar git merge para crear un compromiso de fusión
para el nuevo contenido remoto. Si tiene cambios pendientes en curso
esto causará conflictos y dará inicio a la resolución de conflictos de fusión
fluir.
Con git pull:
No obtienes ningún aislamiento.
No es necesario verificarlo explícitamente. Porque implícitamente hace una fusión de git.
El paso de fusión afectará su desarrollo local y puede causar conflictos
Básicamente NO es seguro. Es agresivo.
A diferencia de git fetch, donde solo afecta a tu .git / refs / remotes, git pull afectará tanto a tu .git / refs / remotes como a .git / refs / heads /
Hmmm ... así que si no estoy actualizando la copia de trabajo con git fetch, ¿dónde estoy haciendo cambios? ¿Dónde almacena Git fetch las nuevas confirmaciones?
Gran pregunta. Lo coloca en algún lugar aislado de su copia de trabajo. Pero, de nuevo, ¿dónde? Vamos a averiguar.
En el directorio de su proyecto (es decir, donde ejecuta sus comandos git) haga:
ls. Esto mostrará los archivos y directorios. Nada genial, lo sé.
Ahora haz ls -a. Esto mostrará archivos de puntos, es decir, archivos que comienzan con. A continuación, podrá ver un directorio llamado: .git.
Haz cd .git. Obviamente, esto cambiará su directorio.
Ahora viene la parte divertida; hacer ls. Verá una lista de directorios. Buscamos árbitros. Hacer referencias de cd.
Es interesante ver qué hay dentro de todos los directorios, pero centrémonos en dos de ellos. cabezas y mandos a distancia. Utilice cd para comprobar su interior también.
Cualquier búsqueda de git que hagas actualizará los elementos en el directorio /.git/refs/remotes. No actualizará nada en el directorio /.git/refs/heads.
Cualquier git pull primero hará el git fetch, actualizará los elementos en el directorio /.git/refs/remotes, luego se fusionará con su local y luego cambiará el encabezado dentro del directorio /.git/refs/heads.
También se puede encontrar una muy buena respuesta relacionada en ¿Dónde se coloca 'git fetch' ?.
Además, busque la "notación Slash" en la publicación de convenciones de nomenclatura de ramas de Git. Te ayuda a comprender mejor cómo Git coloca las cosas endiferentes directorios.
Para ver la diferencia real
Solo haz:
maestro de origen de git fetch
maestro de git checkout
Si se actualizó el maestro remoto, recibirá un mensaje como este:
Su rama está detrás de 'origen / maestro' por 2 confirmaciones y se puede reenviar rápidamente.
(use "git pull" para actualizar su sucursal local)
Si no buscaste y solo hiciste git checkout master, entonces tu git local no sabría que hay 2 confirmaciones agregadas. Y solo diría:
Ya en 'maestro'
Su sucursal está actualizada con 'origen / maestro'.
Pero eso está desactualizado e incorrecto. Es porque git le dará comentarios basados ​​únicamente en lo que sabe. Es ajeno a las nuevas confirmaciones que aún no ha eliminado ...
¿Hay alguna forma de ver los nuevos cambios realizados en remoto mientras se trabaja en la sucursal localmente?
Algunos IDE (por ejemplo, Xcode) son súper inteligentes y usan el resultado de un git fetch y pueden anotar las líneas de código que se han cambiado en la rama remota de su rama de trabajo actual. Si esa línea ha sido cambiada tanto por cambios locales como por rama remota, entonces esa línea se anota en rojo. Este no es un conflicto de fusión. Es un posible conflicto de fusión. Es un aviso que puede usar para resolver el futuro conflicto de fusión antes de hacer git pull desde la rama remota.
Consejo divertido:
Si buscó una rama remota, por ejemplo hizo:
característica de origen de git fetch / 123
Entonces esto iría a su directorio de controles remotos. Todavía no está disponible en su directorio local. Sin embargo, simplifica su pago a esa sucursal remota por DWIM (haga lo que quiero decir):
función de pago de git / 123
ya no necesitas hacer:
git checkout -b función / 123 origen / función / 123
Para más sobre eso lea aquí
|
La única diferencia entre git pull y git fetch es que:
git pull extrae de una rama remota y la fusiona.
git fetch solo obtiene de la rama remota pero no se fusiona
es decir, git pull = git fetch + git merge ...
|
Git permite que las confirmaciones cronológicamente más antiguas se apliquen después de las confirmaciones más nuevas.
Debido a esto, el acto de transferir confirmaciones entre repositorios se divide en dos pasos:
Copiar nuevas confirmaciones de una rama remota a una copia de esta rama remota dentro del repositorio local.
(operación de repositorio a repositorio) maestro @ remoto >> remoto / origen / maestro @ local
Integrando nuevas confirmaciones a la sucursal local
(operación dentro del repositorio) remoto / origen / maestro @ local >> maestro @ local
Hay dos formas de realizar el paso 2. Puede:
Bifurque la rama local después del último ancestro común y agregue nuevas confirmaciones paralelas a las confirmaciones que son exclusivas del repositorio local, finalizadas fusionando la confirmación, cerrando la bifurcación.
Inserte nuevas confirmaciones después del último ancestro común y vuelva a aplicar las confirmaciones únicas al repositorio local.
En terminología de git, el paso 1 es git fetch, el paso 2 es git merge o git rebase
git pull es git fetch y git merge
|
Git obtiene la rama de la última versión del remoto al local usando dos comandos:
git fetch: Git obtendrá la última versión de remoto a local, pero no se fusionará automáticamente.

maestro de origen de git fetch
git log -p master..origin / master
git fusionar origen / maestro
Los comandos anteriores significan que descargan la última versión de la rama principal desde el origen desde la rama maestra remota a la de origen. Y luego compara la rama maestra local y la rama maestra de origen. Finalmente, fusiona.
git pull: Git obtendrá la última versión del control remoto y se fusionará con el local.

maestro de origen de git pull
El comando anterior es equivalente a git fetch y git merge. En la práctica, git fetch puede ser más seguro porque antes de la fusión podemos ver los cambios y decidir si fusionarnos.
|
¿Cuál es la diferencia entre git pull y git fetch?
Para comprender esto, primero debe comprender que su git local mantiene no solo su repositorio local, sino que también mantiene una copia local del repositorio remoto.
git fetch actualiza su copia local del repositorio remoto. Por ejemplo, si su repositorio remoto es GitHub, es posible que desee recuperar cualquier cambio realizado en el repositorio remoto en su copia local del repositorio remoto. Esto le permitirá realizar operaciones como comparar o fusionar.
git pull, por otro lado, reducirá los cambios en el repositorio remoto al lugar donde guardas tu propio código. Por lo general, git pull hará una búsqueda de git primero para actualizar la copia local del repositorio remoto, y luego fusionará los cambios en su propio repositorio de código y posiblemente en su copia de trabajo.
|
git pull == (git fetch + git merge)
git fetch no cambia en las ramas locales.
Si ya tiene un repositorio local con una configuración remota para el proyecto deseado, puede tomar todas las ramas y etiquetas del control remoto existente usando git fetch. ... Fetch no realiza ningún cambio en las sucursales locales, por lo que deberá fusionar una sucursal remota con una sucursal local emparejada para incorporar los cambios de recuperación nuevos. de github
|
Una representación gráfica simple para principiantes,
aquí,
git pull
buscará el códigodesde el repositorio y rebase con su local ... en git pull existe la posibilidad de que se creen nuevas confirmaciones.
pero en ,
git fetch
obtendrá el código del repositorio y necesitamos volver a establecerlo manualmente usando git rebase
por ejemplo: voy a buscar desde el servidor maestro y volver a basarlo en mi maestro local.
1) git pull (el rebase se hará automáticamente):
git pull origin master
aquí el origen es su repositorio maestro remoto es su sucursal
2) git fetch (es necesario reajustar manualmente):
maestro de origen de git fetch
buscará los cambios del servidor desde el origen. y estará en su local hasta que lo vuelva a colocar por su cuenta. Necesitamos solucionar los conflictos manualmente comprobando los códigos.
origen / maestro de git rebase
esto cambiará la base del código a local. antes de eso, asegúrese de estar en la rama correcta.
|
Tratando de ser claro y sencillo.
El comando git pull es en realidad un atajo para git fetch seguido del comando git merge o git rebase, dependiendo de su configuración. Puede configurar su repositorio de Git para que git pull sea una búsqueda seguida de una rebase.
|
En realidad, Git mantiene una copia de su propio código y
el repositorio remoto.
El comando git fetch actualiza su copia local al obtener datos del repositorio remoto. La razón por la que necesitamos esto es porque alguien más podría haber realizado algunos cambios en el código y usted desea mantenerse actualizado.
El comando git pull trae los cambios en el repositorio remoto donde guardas tu propio código. Normalmente, git pull hace esto haciendo un "git fetch" primero para actualizar la copia local del repositorio remoto, y luego fusiona los cambios en su propio repositorio de código y posiblemente en su copia de trabajo.
|
1
2
Siguiente
Pregunta muy activa. Gana 10 de reputación para responder a esta pregunta. El requisito de reputación ayuda a proteger esta pregunta del spam y de la actividad sin respuesta.
No es la respuesta que estás buscando? Lea otras preguntas con la etiqueta git version-control git-pull git-fetch o formule su propia pregunta.